248 research outputs found
Crawling in Rogue's dungeons with (partitioned) A3C
Rogue is a famous dungeon-crawling video-game of the 80ies, the ancestor of
its gender. Rogue-like games are known for the necessity to explore partially
observable and always different randomly-generated labyrinths, preventing any
form of level replay. As such, they serve as a very natural and challenging
task for reinforcement learning, requiring the acquisition of complex,
non-reactive behaviors involving memory and planning. In this article we show
how, exploiting a version of A3C partitioned on different situations, the agent
is able to reach the stairs and descend to the next level in 98% of cases.Comment: Accepted at the Fourth International Conference on Machine Learning,
Optimization, and Data Science (LOD 2018
On the correctness of a branch displacement algorithm
The branch displacement problem is a well-known problem in assembler design. It revolves around the feature, present in several processor families, of having different instructions, of different sizes, for jumps of different displacements. The problem, which is provably NP-hard, is then to select the instructions such that one ends up with the smallest possible program.
During our research with the CerCo project on formally verifying a C compiler, we have implemented and proven correct an algorithm for this problem. In this paper, we discuss the problem, possible solutions, our specific solutions and the proofs
Verification of PCP-Related Computational Reductions in Coq
We formally verify several computational reductions concerning the Post
correspondence problem (PCP) using the proof assistant Coq. Our verifications
include a reduction of a string rewriting problem generalising the halting
problem for Turing machines to PCP, and reductions of PCP to the intersection
problem and the palindrome problem for context-free grammars. Interestingly,
rigorous correctness proofs for some of the reductions are missing in the
literature
A feasible algorithm for typing in Elementary Affine Logic
We give a new type inference algorithm for typing lambda-terms in Elementary
Affine Logic (EAL), which is motivated by applications to complexity and
optimal reduction. Following previous references on this topic, the variant of
EAL type system we consider (denoted EAL*) is a variant without sharing and
without polymorphism. Our algorithm improves over the ones already known in
that it offers a better complexity bound: if a simple type derivation for the
term t is given our algorithm performs EAL* type inference in polynomial time.Comment: 20 page
Quantitative Models and Implicit Complexity
We give new proofs of soundness (all representable functions on base types
lies in certain complexity classes) for Elementary Affine Logic, LFPL (a
language for polytime computation close to realistic functional programming
introduced by one of us), Light Affine Logic and Soft Affine Logic. The proofs
are based on a common semantical framework which is merely instantiated in four
different ways. The framework consists of an innovative modification of
realizability which allows us to use resource-bounded computations as realisers
as opposed to including all Turing computable functions as is usually the case
in realizability constructions. For example, all realisers in the model for
LFPL are polynomially bounded computations whence soundness holds by
construction of the model. The work then lies in being able to interpret all
the required constructs in the model. While being the first entirely semantical
proof of polytime soundness for light logi cs, our proof also provides a
notable simplification of the original already semantical proof of polytime
soundness for LFPL. A new result made possible by the semantic framework is the
addition of polymorphism and a modality to LFPL thus allowing for an internal
definition of inductive datatypes.Comment: 29 page
A Survey on Retrieval of Mathematical Knowledge
We present a short survey of the literature on indexing and retrieval of
mathematical knowledge, with pointers to 72 papers and tentative taxonomies of
both retrieval problems and recurring techniques.Comment: CICM 2015, 20 page
Maximal Sharing in the Lambda Calculus with letrec
Increasing sharing in programs is desirable to compactify the code, and to
avoid duplication of reduction work at run-time, thereby speeding up execution.
We show how a maximal degree of sharing can be obtained for programs expressed
as terms in the lambda calculus with letrec. We introduce a notion of `maximal
compactness' for lambda-letrec-terms among all terms with the same infinite
unfolding. Instead of defined purely syntactically, this notion is based on a
graph semantics. lambda-letrec-terms are interpreted as first-order term graphs
so that unfolding equivalence between terms is preserved and reflected through
bisimilarity of the term graph interpretations. Compactness of the term graphs
can then be compared via functional bisimulation.
We describe practical and efficient methods for the following two problems:
transforming a lambda-letrec-term into a maximally compact form; and deciding
whether two lambda-letrec-terms are unfolding-equivalent. The transformation of
a lambda-letrec-term into maximally compact form proceeds in three
steps:
(i) translate L into its term graph ; (ii) compute the maximally
shared form of as its bisimulation collapse ; (iii) read back a
lambda-letrec-term from the term graph with the property . This guarantees that and have the same unfolding, and that
exhibits maximal sharing.
The procedure for deciding whether two given lambda-letrec-terms and
are unfolding-equivalent computes their term graph interpretations and , and checks whether these term graphs are bisimilar.
For illustration, we also provide a readily usable implementation.Comment: 18 pages, plus 19 pages appendi
Graphical Reasoning in Compact Closed Categories for Quantum Computation
Compact closed categories provide a foundational formalism for a variety of
important domains, including quantum computation. These categories have a
natural visualisation as a form of graphs. We present a formalism for
equational reasoning about such graphs and develop this into a generic proof
system with a fixed logical kernel for equational reasoning about compact
closed categories. Automating this reasoning process is motivated by the slow
and error prone nature of manual graph manipulation. A salient feature of our
system is that it provides a formal and declarative account of derived results
that can include `ellipses'-style notation. We illustrate the framework by
instantiating it for a graphical language of quantum computation and show how
this can be used to perform symbolic computation.Comment: 21 pages, 9 figures. This is the journal version of the paper
published at AIS
- …